Proof in Context -- Web Editing with Rich, Modeless Contextual Feedback

The Agora system is a prototypical Wiki for formal mathematics: a web-based system for collaborating on formal mathematics, intended to support informal documentation of formal developments. This system requires a reusable proof editor component, both for collaborative editing of documents, and for embedding in the resulting documents. This paper describes the design of Agora's asynchronous editor, that is generic enough to support different tools working on editor content and providing contextual information, with interactive theorem proverss being a special, but important, case described in detail for the Coq theorem prover.Comment: In Proceedings UITP 2012, arXiv:1307.152

PIDE for Asynchronous Interaction with Coq

This paper describes the initial progress towards integrating the Coq proof assistant with the PIDE architecture initially developed for Isabelle. The architecture is aimed at asynchronous, parallel interaction with proof assistants, and is tied in heavily with a plugin that allows the jEdit editor to work with Isabelle. We have made some generalizations to the PIDE architecture to accommodate for more provers than just Isabelle, and adapted Coq to understand the core protocol: this delivered a working system in about two man-months.Comment: In Proceedings UITP 2014, arXiv:1410.785

Asynchronous processing of Coq documents: from the kernel up to the user interface

The work described in this paper improves the reactivity of the Coq system by completely redesigning the way it processes a formal document. By subdividing such work into independent tasks the system can give precedence to the ones of immediate interest for the user and postpones the others. On the user side, a modern interface based on the PIDE middleware aggregates and present in a consistent way the output of the prover. Finally postponed tasks are processed exploiting modern, parallel, hardware to offer better scalability.Comment: in Proceedings of ITP, Aug 2015, Nanjing, Chin

Asynchronous processing of Coq documents: from the kernel up to the user interface

International audienceThe work described in this paper improves the reactivity of the Coq system by completely redesigning the way it processes a formal document. By subdividing such work into independent tasks the system can give precedence to the ones of immediate interest for the user and postpones the others. On the user side, a modern interface based on the PIDE middleware aggregates and present in a consistent way the output of the prover. Finally postponed tasks are processed exploiting modern, parallel, hardware to offer better scalability

Coqoon

International audienceUser interfaces for interactive proof assistants have always lagged behind those for mainstream programming languages. Whereas integrated development environments (IDEs) have support for features like project management, version control, dependency analysis and incremental project compilation, " IDE " s for proof assistants typically only operate on files in isolation, relying on external tools to integrate those files into larger projects. In this paper we present Coqoon, an IDE for Coq projects integrated into Eclipse. Coqoon manages proofs as projects rather than isolated source files, and compiles these projects using the Eclipse common build system. Coqoon takes advantage of the latest features of Coq, including asynchronous and parallel processing of proofs, and—when used together with a third-party OCaml extension for Eclipse—can even be used to work on large developments containing Coq plugins

Coqoon An IDE for interactive proof development in Coq

International audienceUser interfaces for interactive proof assistants have always lagged behind those for mainstream programming languages. Whereas integrated development environments—IDEs—have support for features like project management, version control, dependency analysis and in-cremental project compilation, " IDE " s for proof assistants typically only operate on files in isolation, relying on external tools to integrate those files into larger projects. In this paper we present Coqoon, an IDE for Coq developments integrated into Eclipse. Coqoon manages proofs as projects rather than isolated source files, and compiles these projects using the Eclipse common build system. Coqoon takes advantage of the latest features of Coq, including asynchronous and parallel processing of proofs, and—when used together with a third-party OCaml extension for Eclipse—can even be used to work on large developments containing Coq plugins

Asynchronous Editing for Coq

International audienceIn this talk, I will demonstrate the integration of the jEdit editor with Coq, developed as part of the Paral-ITP project. jEdit is an editor with very little off-the-shelf functionality, designed to be extended by language-specific plugins. These plugins receive user changes asynchronously, and use these changes to produce feedback. Because the computation model is asynchronous, there is no way for the user to instruct where and when the proof assistant computes on the proof script, as in Proof General and CoqIDE. Instead, the proof assistant plugin is always active in the background, and automatically reacts to changes in the script, reporting states, errors and markup information. The main intent of the talk is to demonstrate the tool, and discuss the differences between asynchronous and synchronous interaction, as well as the future directions of the middleware used by jEdit to communicate with the prover. There are two main benefits to interacting asynchronously with Coq. The first is more freedom for the author in editing the proof, the second is that it allows the proof assistant to schedule the processing of a proof more sophisti-catedly. Interaction benefits The main benefit in interaction is that, in jEdit, the author can edit a proof script at any place, adding lemmas and modifying proofs, without advancing the computation of the prover. In fact, errors that the author introduces in a script do not always influence the state of future proofs, and the author is free to move between to proves to get the statement of a lemma just right before finishing a proof. Sophistication of Computation Scheduling In the ProofGeneral model, the proof structure is revealed to the proof assistant step by step, and the user always wants feedback for the last line executed. In an asynchronous model, the entire proof script is available to the proof assistant at once, and can be used to compute the structure of the proof. This structure can then be used to schedule computations, possibly in parallel, to provide the user with feedback immediately. For example, consider a proof with two lemmas. The first takes a long time to verify, but the user wants to edit the second. In ProofGeneral, when the user focuses on the second lemma, the proof assistant would first verify the first lemma, taking a long time and only then give the control back to the user

Formal mathematics on display : a wiki for Flyspeck

The Agora system is a prototype Wiki for Formal Mathematics , with an aim to support developing and documenting large formalizations of mathematics in a proof assistant. The functions implemented in Agora include in-browser editing, strong AI/ATP proof advice, verification, and HTML rendering. The HTML rendering contains hyperlinks and provides on-demand explanation of the proof state for each proof step. In the present paper we show the prototype Flyspeck Wiki as an instance of Agora for HOL Light formalizations. The wiki can be used for formalizations of mathematics and for writing informal wiki pages about mathematics. Such informal pages may contain islands of formal text, which is used here for providing an initial cross-linking between Hales's informal Flyspeck book, and the formal Flyspeck development. The Agora platform intends to address distributed wiki-style collaboration on large formalization projects, in particular both the aspect of immediate editing, verification and rendering of formal code, and the aspect of gradual and mutual refactoring and correspondence of the initial informal text and its formalization. Here, we highlight these features within the Flyspeck Wiki